tests/qunit/suites/resources/mediawiki.rcfilters/UriProcessor.test.js

   1 /* eslint-disable camelcase */
   2 /* eslint no-underscore-dangle: "off" */
   3 ( function ( mw, $ ) {
   4         var mockFilterStructure = [ {
   5                         name: 'group1',
   6                         title: 'Group 1',
   7                         type: 'send_unselected_if_any',
   8                         filters: [
   9                                 { name: 'filter1', cssClass: 'filter1class', default: true },
  10                                 { name: 'filter2', cssClass: 'filter2class' }
  11                         ]
  12                 }, {
  13                         name: 'group2',
  14                         title: 'Group 2',
  15                         type: 'send_unselected_if_any',
  16                         filters: [
  17                                 { name: 'filter3', cssClass: 'filter3class' },
  18                                 { name: 'filter4', cssClass: 'filter4class', default: true }
  19                         ]
  20                 }, {
  21                         name: 'group3',
  22                         title: 'Group 3',
  23                         type: 'string_options',
  24                         filters: [
  25                                 { name: 'filter5', cssClass: 'filter5class' },
  26                                 { name: 'filter6' } // Not supporting highlights
  27                         ]
  28                 }, {
  29                         name: 'group4',
  30                         title: 'Group 4',
  31                         type: 'boolean',
  32                         sticky: true,
  33                         filters: [
  34                                 { name: 'stickyFilter7', cssClass: 'filter7class' },
  35                                 { name: 'stickyFilter8', cssClass: 'filter8class' }
  36                         ]
  37                 } ],
  38                 minimalDefaultParams = {
  39                         filter1: '1',
  40                         filter4: '1'
  41                 };
  42
  43         QUnit.module( 'mediawiki.rcfilters - UriProcessor' );
  44
  45         QUnit.test( 'getVersion', function ( assert ) {
  46                 var uriProcessor = new mw.rcfilters.UriProcessor( new mw.rcfilters.dm.FiltersViewModel() );
  47
  48                 assert.ok(
  49                         uriProcessor.getVersion( { param1: 'foo', urlversion: '2' } ),
  50                         2,
  51                         'Retrieving the version from the URI query'
  52                 );
  53
  54                 assert.ok(
  55                         uriProcessor.getVersion( { param1: 'foo' } ),
  56                         1,
  57                         'Getting version 1 if no version is specified'
  58                 );
  59         } );
  60
  61         QUnit.test( 'getUpdatedUri', function ( assert ) {
  62                 var uriProcessor,
  63                         filtersModel = new mw.rcfilters.dm.FiltersViewModel();
  64
  65                 filtersModel.initializeFilters( mockFilterStructure );
  66                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
  67
  68                 assert.deepEqual(
  69                         ( uriProcessor.getUpdatedUri( {} ) ).query,
  70                         { urlversion: '2' },
  71                         'Empty model state with empty uri state, assumes the given uri is already normalized, and adds urlversion=2'
  72                 );
  73
  74                 assert.deepEqual(
  75                         ( uriProcessor.getUpdatedUri( { foo: 'bar' } ) ).query,
  76                         { urlversion: '2', foo: 'bar' },
  77                         'Empty model state with unrecognized params retains unrecognized params'
  78                 );
  79
  80                 // Update the model
  81                 filtersModel.toggleFiltersSelected( {
  82                         group1__filter1: true, // Param: filter2: '1'
  83                         group3__filter5: true // Param: group3: 'filter5'
  84                 } );
  85
  86                 assert.deepEqual(
  87                         ( uriProcessor.getUpdatedUri( {} ) ).query,
  88                         { urlversion: '2', filter2: '1', group3: 'filter5' },
  89                         'Model state is reflected in the updated URI'
  90                 );
  91
  92                 assert.deepEqual(
  93                         ( uriProcessor.getUpdatedUri( { foo: 'bar' } ) ).query,
  94                         { urlversion: '2', filter2: '1', group3: 'filter5', foo: 'bar' },
  95                         'Model state is reflected in the updated URI with existing uri params'
  96                 );
  97         } );
  98
  99         QUnit.test( 'updateModelBasedOnQuery', function ( assert ) {
 100                 var uriProcessor,
 101                         filtersModel = new mw.rcfilters.dm.FiltersViewModel();
 102
 103                 filtersModel.initializeFilters( mockFilterStructure );
 104                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 105
 106                 uriProcessor.updateModelBasedOnQuery( {} );
 107                 assert.deepEqual(
 108                         filtersModel.getCurrentParameterState(),
 109                         minimalDefaultParams,
 110                         'Version 1: Empty url query sets model to defaults'
 111                 );
 112
 113                 uriProcessor.updateModelBasedOnQuery( { urlversion: '2' } );
 114                 assert.deepEqual(
 115                         filtersModel.getCurrentParameterState(),
 116                         {},
 117                         'Version 2: Empty url query sets model to all-false'
 118                 );
 119
 120                 uriProcessor.updateModelBasedOnQuery( { filter1: '1', urlversion: '2' } );
 121                 assert.deepEqual(
 122                         filtersModel.getCurrentParameterState(),
 123                         $.extend( true, {}, { filter1: '1' } ),
 124                         'Parameters in Uri query set parameter value in the model'
 125                 );
 126         } );
 127
 128         QUnit.test( 'isNewState', function ( assert ) {
 129                 var uriProcessor,
 130                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 131                         cases = [
 132                                 {
 133                                         states: {
 134                                                 curr: {},
 135                                                 new: {}
 136                                         },
 137                                         result: false,
 138                                         message: 'Empty objects are not new state.'
 139                                 },
 140                                 {
 141                                         states: {
 142                                                 curr: { filter1: '1' },
 143                                                 new: { filter1: '0' }
 144                                         },
 145                                         result: true,
 146                                         message: 'Nulified parameter is a new state'
 147                                 },
 148                                 {
 149                                         states: {
 150                                                 curr: { filter1: '1' },
 151                                                 new: { filter1: '1', filter2: '1' }
 152                                         },
 153                                         result: true,
 154                                         message: 'Added parameters are a new state'
 155                                 },
 156                                 {
 157                                         states: {
 158                                                 curr: { filter1: '1' },
 159                                                 new: { filter1: '1', filter2: '0' }
 160                                         },
 161                                         result: false,
 162                                         message: 'Added null parameters are not a new state (normalizing equals old state)'
 163                                 },
 164                                 {
 165                                         states: {
 166                                                 curr: { filter1: '1' },
 167                                                 new: { filter1: '1', foo: 'bar' }
 168                                         },
 169                                         result: true,
 170                                         message: 'Added unrecognized parameters are a new state'
 171                                 },
 172                                 {
 173                                         states: {
 174                                                 curr: { filter1: '1', foo: 'bar' },
 175                                                 new: { filter1: '1', foo: 'baz' }
 176                                         },
 177                                         result: true,
 178                                         message: 'Changed unrecognized parameters are a new state'
 179                                 }
 180                         ];
 181
 182                 filtersModel.initializeFilters( mockFilterStructure );
 183                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 184
 185                 cases.forEach( function ( testCase ) {
 186                         assert.equal(
 187                                 uriProcessor.isNewState( testCase.states.curr, testCase.states.new ),
 188                                 testCase.result,
 189                                 testCase.message
 190                         );
 191                 } );
 192         } );
 193
 194         QUnit.test( 'doesQueryContainRecognizedParams', function ( assert ) {
 195                 var uriProcessor,
 196                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 197                         cases = [
 198                                 {
 199                                         query: {},
 200                                         result: false,
 201                                         message: 'Empty query is not valid for load.'
 202                                 },
 203                                 {
 204                                         query: { highlight: '1' },
 205                                         result: false,
 206                                         message: 'Highlight state alone is not valid for load'
 207                                 },
 208                                 {
 209                                         query: { urlversion: '2' },
 210                                         result: true,
 211                                         message: 'urlversion=2 state alone is valid for load as an empty state'
 212                                 },
 213                                 {
 214                                         query: { filter1: '1', foo: 'bar' },
 215                                         result: true,
 216                                         message: 'Existence of recognized parameters makes the query valid for load'
 217                                 },
 218                                 {
 219                                         query: { foo: 'bar', debug: true },
 220                                         result: false,
 221                                         message: 'Only unrecognized parameters makes the query invalid for load'
 222                                 }
 223                         ];
 224
 225                 filtersModel.initializeFilters( mockFilterStructure );
 226                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 227
 228                 cases.forEach( function ( testCase ) {
 229                         assert.equal(
 230                                 uriProcessor.doesQueryContainRecognizedParams( testCase.query ),
 231                                 testCase.result,
 232                                 testCase.message
 233                         );
 234                 } );
 235         } );
 236
 237         QUnit.test( '_getNormalizedQueryParams', function ( assert ) {
 238                 var uriProcessor,
 239                         filtersModel = new mw.rcfilters.dm.FiltersViewModel(),
 240                         cases = [
 241                                 {
 242                                         query: {},
 243                                         result: $.extend( true, { urlversion: '2' }, minimalDefaultParams ),
 244                                         message: 'Empty query returns defaults (urlversion 1).'
 245                                 },
 246                                 {
 247                                         query: { urlversion: '2' },
 248                                         result: { urlversion: '2' },
 249                                         message: 'Empty query returns empty (urlversion 2)'
 250                                 },
 251                                 {
 252                                         query: { filter1: '0' },
 253                                         result: { urlversion: '2', filter4: '1' },
 254                                         message: 'urlversion 1 returns query that overrides defaults'
 255                                 },
 256                                 {
 257                                         query: { filter3: '1' },
 258                                         result: { urlversion: '2', filter1: '1', filter4: '1', filter3: '1' },
 259                                         message: 'urlversion 1 with an extra param value returns query that is joined with defaults'
 260                                 }
 261                         ];
 262
 263                 filtersModel.initializeFilters( mockFilterStructure );
 264                 uriProcessor = new mw.rcfilters.UriProcessor( filtersModel );
 265
 266                 cases.forEach( function ( testCase ) {
 267                         assert.deepEqual(
 268                                 uriProcessor._getNormalizedQueryParams( testCase.query ),
 269                                 testCase.result,
 270                                 testCase.message
 271                         );
 272                 } );
 273         } );
 274
 275 }( mediaWiki, jQuery ) );